%\section{Desarrollo}
\begin{section}{Desarrollo}
Para la resoluci\'on del problema se han implementado los m\'etodos de $Newton-Raphson$ y $Secante$ para aproximar cero de funciones. Estos m\'etodos nos ayudar\'an a encontrar sucesiones que converjan aproximadamente a la ra\'iz de la funcion $funcionCero(t)$ y as\'i poder verificar cuando esta funci\'on es negativa ($A(t) > C$), lo cual implica que Superman caiga.\\
En un principio nos motiv\'o la idea de llegar a la soluci\'on bajo el m\'etodo de Bisecci\'on en lugar de la $Secante$ dado su f\'acil implementaci\'on. Sin embargo, este algoritmo, en uno de sus requerimientos (bas\'andose en el $Teorema$ $del$ $valor$ $intermedio$) pide que se cumpla la hip\'otesis $funcionCero(t_0)*funcionCero(t_1) < 0$. El encontrar ambos $t$ inciales requiere muchos c\'alculos e iteraciones sin asegurarnos poder encontrar los valores para poder inciar el m\'etodo, por lo cual se ha descartado Bisecci\'on.\\\\
Analicemos el M\'etodo $Newton-Raphson$\\
El algoritmo implementado es el siguiente:\\
\begin{verbatim}
while (iter < itersMax){
	
	if(fabs(this->funcionCeroDerivada(p_0).dbl()) < tolerancia.dbl()){
			//p_0 ES EXTREMO, es máximo o mínimo local
			if ((funcionCero(p).dbl() < tolerancia.dbl())){
				cout<<"Solución del Método Newton_Raphson: "<< p.dbl()<< "  (en " << iter << " iteraciones)"<<endl;
				cout<<"Cayó Superman"<<endl;
				return p;
			}
		}
	
	if ((funcionCero(p).dbl() < tolerancia.dbl())){
		cout<<"Solución del Método Newton_Raphson: "<< p.dbl()<< "  (en " << iter << " iteraciones)"<<endl;
		cout<<"Cayó Superman"<<endl;
		return p;
	}
	
	//CHECK FOR OVERFLOW LA DIVISION POR LA DERIVADA MUY CHICA
	if (fabs((this->funcionCero(p_0) / this->funcionCeroDerivada(p_0)).dbl()) > std::numeric_limits<double>::max()){
		throw 1;
	}else{
	    //Sucesion de Newton:
		p = p_0 - (this->funcionCero(p_0) / this->funcionCeroDerivada(p_0));
	}

	iter++;
	p_0 = p;
}
\end{verbatim}
Lo primero que hacemos es analizar si se cumplen las hip\'otesis para poder utilizar este m\'etodo. Para su ejecuci\'on necesitamos que $funcionCero$ sea derivable, lo cu\'al se cumple, obteniendo como $funcionCeroDerivada()$ lo siguiente:
\begin{displaymath}
funcionCeroDerivada(t) \ = \sum_{i=1}^n {a^{t}*(f(t)-x_i)\over ((f(t) - x_i)^{t}*(f(t) - x_i))^{3/2}}.\\
\end{displaymath}\\ 
Este c\'odigo implementa la sucesi\'on:
\begin{displaymath} 
x_{n+1} \ = x_n - \frac{funcionCero(x_n)}{funcionCeroDerivada(x_n)}.\\ 
\end{displaymath}\\ 
El algortimo lo repetimos mientras no se cumpla alguno de los criterios de parada: no se supere una cantidad m\'axima de iteraciones ($itersMax$), para el caso en que la sucesi\'on no converja, y mientras $funcionCero(p)$ no sea menor a la tolerancia deseada. Finalmente, se devuelve el \'ultimo elemento de la sucesi\'on que ser\'a aquel que se encuentre m\'as cerca de la ra\'iz. 
El algortimo obtiene las aproximaciones usandos tangentes sucesivas, comenzando con la aproximaci\'on lineal en $p_0$ y luego $p_1$ ser\'a el punto de intersecci\'on de la recta tangente de $funcionCero(p_0)$ con el eje $x$.
Uno de los problemas que nos surgi\'o en este m\'etodo es que no sab\'iamos con que $p_0$ empezar las iteraciones para que converja la sucesi\'on. Otro problema con que nos encontramos con la desigualdad $funcionCero(p)$ $< tolerancia$ no nos proporciones mucha informaci\'on sobre el error real $|p-p_o|$. Estos mismos criterios de parada son utilizados en el m\'etodo de la $Secante$ que analizaremos a continuaci\'on.\\\\
M\'etodo de la $Secante$\\
El algortimo implementado es el siguiente:\\
\begin{verbatim}
q_0 = this->funcionCero(p_0);
q_1 = this->funcionCero(p_1);
	
int iter = 2;

while (iter < itersMax){
		
	//CHECK FOR OVERFLOW 
	TFloat num = q_1*(p_1-p_0);
	TFloat div = q_1-q_0;
	if(div.dbl()<tolerancia.dbl()){
	//SI DIV ES MUY CHICO AJUSTAMOS EL INTERVALO PARA QUE EL ALGORITMO CONTINUE
		iter++;
		p = ((p_1-p_0)/TFloat(4, this->_precision)*TFloat(1, this->_precision)) + p_0;
		p_0 = p_1;
		q_0 = q_1;
		p_1 = p;
		q_1 = this->funcionCero(p);	
		continue;
	}
	
	//CHECK FOR OVERFLOW 	
	if ((num.dbl()/div.dbl()) > std::numeric_limits<double>::max()){	
		throw 1;
	}else{
        //Sucesion de Secante:
		p = p_1 - ((q_1*(p_1-p_0))/(q_1-q_0));
		//SI P SE VA DEL INTERVALO LO SETEAMOS A EL PUNTO INTERMEDIO ENTRE LOS DOS LIMITES PARA
		 AUMENTAR LAS POSIBILIDADES DE CONVERGENCIA DEL METODO
		if((p.dbl()<tolerancia.dbl())||(p.dbl()>(tolerancia+TFloat(1,this->_precision)).dbl())){
			p = (p_0 + p_1)/TFloat(2, this->_precision);
		}
	}

	if ((funcionCero(p)).dbl() < tolerancia.dbl()){
		cout<<"Solución del Método Secante: "<< p.dbl()<< "  (en " << iter << " iteraciones)"<<endl;
		cout<<"Cayó Superman"<<endl;
		return p;
		}

	iter++;
	p_0 = p_1;
	q_0 = q_1;
	p_1 = p;
	q_1 = this->funcionCero(p);		
}
\end{verbatim}
El c\'odigo implementa la relaci\'on de recurrencia:
\begin{displaymath}
x_{n+1} \ = x_n - \frac{x_n-x_{n-1}}{funcionCero(x_n)-funcionCero(x_{n-1})}funcionCero(x_n).\\
\end{displaymath}\\
Para $Secante$ se han establecido los mismos criterios de parada que para el m\'etodo de $Newton-Raphson$. Este m\'etodo necesita dos aproximaciones lineales para poder incluir una pendiente inicial. Como su nombre lo dice, este m\'etodo va trazando rectas secantes a la curva original y despu\'es del primer paso no depende de las cantidades sino que va utilizando las ya obtenidas.\\\\
En ambos m\'etodos se tuvo que tener en cuenta la situación donde el denominador que aparece en la sucesi\'on es muy chico. Al realizar esta operaci\'on, los resultados obtenidos superan los valores posibles que puede representar una computadora, dado que la suma empieza a tender hacia infinito, lo cual genera $overflow$. En los casos que esto ocurra en el algoritmo, el mismo se detiene devolvi\'endo el valor obtenido en la \'ultima iteraci\'on que logr\'o realizar sin dificultades num\'ericas, indicando que Supeman ha ca\'ido. 
En el caso del m\'etodo $Newton-Raphson$ el denominador es $funcionCeroDerivada(t)$ lo cual significa que si este número es muy chico nos estamos acercando a un extremo (m\'aximo o m\'inimo local) de la $funcionCero$.
Al pedir que el denominador sea mayor a una tolerancia se contempla el caso que el sea distinto a cero, para que no se indefina la sucesi\'on.
Otro inconveniente que tuvimos con ambos m\'etodos es que son m\'etodos iterativos los dos y por eso mismo corren el riesgo de no converger a la ra\'iz si no se eligen puntos iniciales adecuados.\\
Para poder probar los m\'etodos implementados tomamos 5 casos donde Superman se desplaza por la ciudad. En cada caso, var\'ian la cantidad de piedras y su ubicaci\'on. Para cada uno, se midieron la precisi\'on obtenida y la cantidad de iteraciones hasta obtener un valor menor a la tolerancia requerida. En el caso 1 y el caso 2, la \'unica diferencia radica en el valor cr\'itico de nuestro h\'eroe, esta diferencia genera un resultado distinto en ambos casos, haciendo que Superman pase a caer a poder atravesar la ciudad sin inconvenientes.
En los casos restantes se aumenta la cantidad de piedras en el camino y se ponen muy cerca del recorrido de Superman.\\
Estimamos que al comparar ambos m\'etodos en estos casos puntuales, $Newton-Raphson$, al tener un orden de convergencia cuadr\'atrica, llegue a una soluci\'on aproximada de una forma m\'as veloz que $Secante$. Para algunos casos, seguramente, vamos a encontrarnos con incidentes debido a los valores inciales que tomemos en ambos m\'etodos, por lo cual tendremos cuidado si la sucesi\'on no converge para el primer punto incial que ingresemos y probaremos con otros valores.   

\end{section}




